home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / Resources / CutePDF 2.3 / converter.exe / GNUGS / GS_FONTS.PS < prev    next >
Text File  |  2002-04-03  |  34KB  |  1,041 lines
  1. %    Copyright (C) 1990, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: gs_fonts.ps,v 1.13.2.3 2002/04/02 13:57:27 mpsuzuki Exp $
  17. % Font initialization and management code.
  18.  
  19. % Define the default font.
  20. /defaultfontname /Courier def
  21.  
  22. % Define the name of the font map file.
  23. /defaultfontmap (Fontmap) def
  24.  
  25. % ------ End of editable parameters ------ %
  26.  
  27. % Define the UniqueIDs and organization XUID assigned to Aladdin.
  28. % UniqueIDs 5,066,501 - 5,066,580 are assigned as follows:
  29. %   01 and 02 for shareware Cyrillic
  30. %   33 through 67 for Type 1 versions of the Hershey fonts
  31. % UniqueIDs 5,115,501 - 5,115,600 are currently unassigned.
  32. /AladdinEnterprisesXUID 107 def
  33.  
  34. % If SUBSTFONT is defined, make it the default font.
  35. /SUBSTFONT where { pop /defaultfontname /SUBSTFONT load def } if
  36.  
  37. % Define a reliable way of accessing FontDirectory in systemdict.
  38. /.FontDirectory
  39. { /FontDirectory .systemvar
  40. } .bind odef
  41.  
  42. % If DISKFONTS is true, we load individual CharStrings as they are needed.
  43. % (This is intended primarily for machines with very small memories.)
  44. % In this case, we define another dictionary, parallel to FontDirectory,
  45. % that retains an open file for every font loaded.
  46. /FontFileDirectory 10 dict def
  47.  
  48. % Define a temporary string for local use, since using =string
  49. % interferes with some PostScript programs.
  50. /.fonttempstring 128 string def
  51.  
  52. % Split up a search path into individual directories or files.
  53. /.pathlist        % <path> .pathlist <dir1|file1> ...
  54.  {  { dup length 0 eq { pop exit } if
  55.       .filenamelistseparator search not { exit } if
  56.       exch pop exch
  57.     }
  58.    loop
  59.  } bind def
  60.  
  61. % Load a font name -> font file name map.
  62. userdict /Fontmap .FontDirectory maxlength dict put
  63. /.loadFontmap {        % <file> .loadFontmap -
  64.         % We would like to simply execute .definefontmap as we read,
  65.         % but we have to maintain backward compatibility with an older
  66.         % specification that makes later entries override earlier
  67.         % ones within the same file.
  68.    50 dict exch .readFontmap
  69.     { .definefontmap } forall
  70. } bind def
  71. /.readFontmap {        % <dict> <file> .readFontmap <dict>
  72.     { dup token not { closefile exit } if
  73.         % stack: dict file fontname
  74.       % This is a hack to get around the absurd habit of MS-DOS editors
  75.       % of adding an EOF character at the end of the file.
  76.       dup (\032) eq { pop closefile exit } if
  77.       1 index token not
  78.        { (Fontmap entry for ) print dup =only
  79.      ( has no associated file or alias name!  Giving up.) = flush
  80.      {.readFontmap} 0 get 1 .quit
  81.        } if
  82.       dup type dup /stringtype eq exch /nametype eq or not
  83.        { (Fontmap entry for ) print 1 index =only
  84.      ( has an invalid file or alias name!  Giving up.) = flush
  85.      {.readFontmap} 0 get 1 .quit
  86.        } if
  87.         % stack: dict file fontname filename|aliasname
  88.       1 index type /stringtype eq
  89.       1 index type /nametype eq and 1 index xcheck and
  90.       1 index /run eq 2 index /.runlibfile eq or and {
  91.         % This is an inclusion entry.
  92.     pop findlibfile { exch pop } { file } ifelse
  93.     2 index exch .readFontmap pop
  94.       } {
  95.         % This is a real entry.
  96.         % Read and pop tokens until a semicolon.
  97.        { 2 index token not
  98.       { (Fontmap entry for ) print 1 index =only
  99.         ( ends prematurely!  Giving up.) = flush
  100.         {.loadFontmap} 0 get 1 .quit
  101.       } if
  102.      dup /; eq { pop 3 index 3 1 roll .growput exit } if
  103.      pop
  104.        } loop
  105.       } ifelse
  106.     } loop
  107. } bind def
  108. % Add an entry in Fontmap.  We redefine this if the Level 2
  109. % resource machinery is loaded.
  110. /.definefontmap            % <fontname> <file|alias> .definefontmap -
  111.  {        % Since Fontmap is global, make sure the values are storable.
  112.    .currentglobal 3 1 roll true .setglobal
  113.    dup type /stringtype eq
  114.     { dup .gcheck not { dup length string copy } if
  115.     }
  116.    if
  117.    Fontmap 3 -1 roll 2 copy .knownget
  118.     {        % Add an element to the end of the existing value,
  119.         % unless it's the same as the current last element.
  120.       mark exch aload pop counttomark 4 add -1 roll
  121.       2 copy eq { cleartomark pop pop } { ] readonly .growput } ifelse
  122.     }
  123.     {        % Make a new entry.
  124.       mark 4 -1 roll ] readonly .growput
  125.     }
  126.    ifelse .setglobal
  127.  } bind def
  128.  
  129. % Parse a font file just enough to find the FontName or FontType.
  130. /.findfontvalue {    % <file> <key> .findfontvalue <value> true
  131.             % <file> <key> .findfontvalue false
  132.             % Closes the file in either case.
  133.   exch dup read not { -1 } if
  134.   2 copy unread 16#80 eq {
  135.     dup (xxxxxx) readstring pop pop        % skip .PFB header
  136.   } if
  137.   {        % Stack: key file
  138.         % Protect ourselves against syntax errors here.
  139.     dup { token } stopped { pop false exit } if
  140.     not { false exit } if        % end of file
  141.     dup /eexec eq { pop false exit } if        % reached eexec section
  142.     dup /Subrs eq { pop false exit } if        % Subrs without eexec
  143.     dup /CharStrings eq { pop false exit } if    % CharStrings without eexec
  144.     dup 3 index eq
  145.      { xcheck not { dup token exit } if }    % found key
  146.      { pop }
  147.     ifelse
  148.   } loop
  149.         % Stack: key file value true   (or)
  150.         % Stack: key file false
  151.   dup { 4 } { 3 } ifelse -2 roll closefile pop
  152. } bind def
  153. /.findfontname
  154.  { /FontName .findfontvalue
  155.  } bind def
  156.  
  157. % If there is no FONTPATH, try to get one from the environment.
  158. NOFONTPATH { /FONTPATH () def } if
  159. /FONTPATH where
  160.  { pop }
  161.  { /FONTPATH (GS_FONTPATH) getenv not { () } if def }
  162. ifelse
  163. FONTPATH length 0 eq { (%END FONTPATH) .skipeof } if
  164. /FONTPATH [ FONTPATH .pathlist ] def
  165.  
  166. % Scan directories looking for plausible fonts.  "Plausible" means that
  167. % the file begins with %!PS-AdobeFont or %!FontType1, or with \200\001
  168. % followed by four arbitrary bytes and then either of these strings.
  169. % To speed up the search, we skip any file whose name appears in
  170. % the Fontmap (with any extension and upper/lower case variation) already,
  171. % and any file whose extension definitely indicates it is not a font.
  172. %
  173. % NOTE: The current implementation of this procedure is somewhat Unix/DOS-
  174. % specific.  It assumes that '/' and '\' are directory separators, and that
  175. % the part of a file name following the last '.' is the extension.
  176. %
  177. /.lowerstring        % <string> .lowerstring <lowerstring>
  178.  { 0 1 2 index length 1 sub
  179.     { 2 copy get dup 65 ge exch 90 le and
  180.        { 2 copy 2 copy get 32 add put }
  181.      if pop
  182.     }
  183.    for
  184.  } bind def
  185. /.splitfilename {    % <dir.../base.extn> .basename <base> <extn>
  186.         % Make the file name read-only to detect aliasing bugs.
  187.         % We really don't like doing this, but we've had one
  188.         % such bug already.
  189.   readonly {
  190.     (/) search { true } { (\\) search } ifelse { pop pop } { exit } ifelse
  191.   } loop
  192.   dup { (.) search { pop pop } { exit } ifelse } loop
  193.   2 copy eq {
  194.     pop ()
  195.   } {
  196.     exch dup length 2 index length 1 add sub 0 exch getinterval exch
  197.   } ifelse
  198. } bind def
  199. /.scanfontdict 1 dict def        % establish a binding
  200. /.scanfontbegin
  201.  {    % Construct the table of all file names already in Fontmap.
  202.    currentglobal true setglobal
  203.    .scanfontdict dup maxlength Fontmap length 2 add .max .setmaxlength
  204.    Fontmap
  205.     { exch pop
  206.        { dup type /stringtype eq
  207.       { .splitfilename pop .fonttempstring copy .lowerstring cvn
  208.         .scanfontdict exch true put
  209.       }
  210.       { pop
  211.       }
  212.      ifelse
  213.        }
  214.       forall
  215.     }
  216.    forall
  217.    setglobal
  218.  } bind def
  219. /.scanfontskip mark
  220.         % Strings are converted to names anyway, so....
  221.   /afm true
  222.   /bat true
  223.   /c true
  224.   /cmd true
  225.   /com true
  226.   /dir true
  227.   /dll true
  228.   /doc true
  229.   /drv true
  230.   /exe true
  231.   /fon true
  232.   /fot true
  233.   /h true
  234.   /o true
  235.   /obj true
  236.   /pfm true
  237.   /pss true        % Adobe Multiple Master font instances
  238.   /txt true
  239. .dicttomark def
  240. /.scan1fontstring 128 string def
  241. % %%BeginFont: is not per Adobe documentation, but a few fonts have it.
  242. /.scanfontheaders [(%!PS-Adobe*) (%!FontType*) (%%BeginFont:*)] def
  243. 0 .scanfontheaders { length .max } forall 6 add    % extra for PFB header
  244. /.scan1fontfirst exch string def
  245. /.scanfontdir        % <dirname> .scanfontdir -
  246.  { currentglobal exch true setglobal
  247.    QUIET not { (Scanning ) print dup print ( for fonts...) print flush } if
  248.    (*) 1 index .filenamedirseparator
  249.    dup (\\) eq { pop (\\\\) } if    % double \ for pattern match
  250.    exch concatstrings concatstrings
  251.    0 0 0 4 -1 roll    % found scanned files
  252.     {        % stack: <fontcount> <scancount> <filecount> <filename>
  253.       exch 1 add exch                   % increment filecount
  254.       dup .splitfilename .fonttempstring copy .lowerstring
  255.         % stack: <fontcount> <scancount> <filecount+1> <filename>
  256.         %    <BASE> <ext>
  257.       .scanfontskip exch known exch .scanfontdict exch known or
  258.        { pop
  259.         % stack: <fontcount> <scancount> <filecount+1>
  260.        }
  261.        { 3 -1 roll 1 add 3 1 roll
  262.         % stack: <fontcount> <scancount+1> <filecount+1> <filename>
  263.      dup (r) { file } .internalstopped
  264.       { pop pop null ()
  265.         % stack: <fontcount> <scancount+1> <filecount+1> <filename>
  266.         %    null ()
  267.       }
  268.       {
  269.         % On some platforms, the file operator will open directories,
  270.         % but an error will occur if we try to read from one.
  271.         % Handle this possibility here.
  272.         dup .scan1fontfirst { readstring } .internalstopped
  273.          { pop pop () }
  274.          { pop }
  275.         ifelse
  276.         % stack: <fontcount> <scancount+1> <filecount+1>
  277.         %    <filename> <file> <header>
  278.       }
  279.      ifelse
  280.         % Check for PFB file header.
  281.      dup (\200\001????*) .stringmatch
  282.       { dup length 6 sub 6 exch getinterval }
  283.      if
  284.         % Check for font file headers.
  285.      false .scanfontheaders
  286.       { 2 index exch .stringmatch or
  287.       }
  288.      forall exch pop
  289.       {    % stack: <fontcount> <scancount+1> <filecount+1> <filename>
  290.         %    <file>
  291.         dup 0 setfileposition .findfontname
  292.          { dup Fontmap exch known
  293.         { pop pop
  294.         }
  295.         { exch copystring exch
  296.           DEBUG { ( ) print dup =only flush } if
  297.           1 index .definefontmap
  298.           .splitfilename pop true .scanfontdict 3 1 roll .growput
  299.             % Increment fontcount.
  300.           3 -1 roll 1 add 3 1 roll
  301.         }
  302.            ifelse
  303.          }
  304.          { pop
  305.          }
  306.         ifelse
  307.       }
  308.         % .findfontname will have done a closefile in the above case.
  309.       { dup null eq { pop } { closefile } ifelse pop
  310.       }
  311.      ifelse
  312.        }
  313.       ifelse
  314.     }
  315.    .scan1fontstring filenameforall
  316.    QUIET
  317.     { pop pop pop }
  318.     { ( ) print =only ( files, ) print =only ( scanned, ) print
  319.       =only ( new fonts.) = flush
  320.     }
  321.    ifelse
  322.    setglobal
  323.  } bind def
  324.  
  325. %END FONTPATH
  326.  
  327. % Create the dictionary that registers the .buildfont procedure (called by
  328. % definefont) for each FontType.
  329. /buildfontdict 20 dict def
  330.  
  331. % Register Type 3 fonts, which are always supported, for definefont.
  332. buildfontdict 3 /.buildfont3 cvx put
  333.  
  334. % Register Type 0 fonts if they are supported.  Strictly speaking,
  335. % we should do this in its own file (gs_type0.ps), but since this is
  336. % the only thing that would be in that file, it's simpler to put it here.
  337. /.buildfont0 where { pop buildfontdict 0 /.buildfont0 cvx put } if
  338.  
  339. % Define definefont.  This is a procedure built on a set of operators
  340. % that do all the error checking and key insertion.
  341. /.growfontdict
  342.  {    % Grow the font dictionary, if necessary, to ensure room for an
  343.     % added entry, making sure there is at least one slot left for FID.
  344.    dup maxlength 1 index length sub 2 lt
  345.     { dup dup wcheck
  346.        { .growdict }
  347.        { .growdictlength dict .copydict }
  348.       ifelse
  349.     }
  350.     { dup wcheck not { dup maxlength dict .copydict } if
  351.     }
  352.    ifelse
  353.  } bind def 
  354. /.completefont {
  355.   {        % Check for disabled platform fonts.
  356.       NOPLATFONTS
  357.        {    % Make sure we leave room for FID.
  358.      .growfontdict dup /ExactSize 0 put
  359.        }
  360.        {    % Hack: if the Encoding looks like it might be the
  361.         % Symbol or Dingbats encoding, load those now (for the
  362.         % benefit of platform font matching) just in case
  363.         % the font didn't actually reference them.
  364.         % Note that some types of font don't have an Encoding.
  365.      dup /Encoding .knownget {
  366.        dup length 65 ge {
  367.          64 get
  368.          dup /congruent eq { SymbolEncoding pop } if
  369.          /a9 eq { DingbatsEncoding pop } if
  370.        } {
  371.          pop
  372.        } ifelse
  373.      } if
  374.        }
  375.       ifelse
  376.       true exch
  377.         % If this is a CIDFont, CIDFontType takes precedence
  378.         % over FontType.
  379.       dup /CIDFontType known {
  380.     /.buildcidfont where {
  381.       pop exch not exch    % true => false
  382.     } if
  383.       } if
  384.       exch {
  385.     dup /FontType get //buildfontdict exch get exec
  386.       } {
  387.     .buildcidfont
  388.       } ifelse
  389.  
  390.       DISKFONTS
  391.        { FontFileDirectory 2 index known
  392.       { dup /FontFile FontFileDirectory 4 index get .growput
  393.       }
  394.      if
  395.        }
  396.       if
  397.       readonly        % stack: name fontdict
  398.   } stopped { /invalidfont signalerror } if
  399. } bind odef
  400. /definefont
  401.  { .completefont
  402.         % If the current allocation mode is global, also enter
  403.         % the font in LocalFontDirectory.
  404.    .currentglobal
  405.     { //systemdict /LocalFontDirectory .knownget
  406.        { 2 index 2 index .growput }
  407.       if
  408.     }
  409.    if
  410.    dup .FontDirectory 4 -2 roll .growput
  411.         % If the font originated as a resource, register it.
  412.    currentfile .currentresourcefile eq { dup .registerfont } if
  413.  } odef
  414.  
  415. % Define a procedure for defining aliased fonts.
  416. % We use this only for explicitly aliased fonts, not substituted fonts:
  417. % we think this matches the observed behavior of Adobe interpreters.
  418. /.aliasfont        % <name> <font> .aliasfont <newFont>
  419.  { .currentglobal 3 1 roll dup .gcheck .setglobal
  420.    dup length 2 add dict
  421.    dup 3 -1 roll { 1 index /FID eq { pop pop } { put dup } ifelse } forall
  422.         % Stack: global fontname newfont newfont.
  423.         % We might be defining a global font whose FontName
  424.         % is a local string.  This is weird, but legal,
  425.         % and doesn't cause problems anywhere else:
  426.         % to avoid any possible problems in this case, do a cvn.
  427.         % We might also be defining (as an alias) a global font
  428.         % whose FontName is a local non-string, if someone passed a
  429.         % garbage value to findfont.  In this case, just don't
  430.         % call definefont at all.
  431.    2 index dup type /stringtype eq exch .gcheck or 1 index .gcheck not or
  432.     { /FontName 3 index dup type /stringtype eq { cvn } if put
  433.         % Don't bind in definefont, since Level 2 redefines it.
  434.       /definefont .systemvar exec
  435.     }
  436.     { .completefont pop exch pop
  437.     }
  438.    ifelse exch .setglobal
  439.  } odef        % so findfont will bind it
  440.  
  441. % Define .loadfontfile for loading a font.  If we recognize Type 1 and/or
  442. % TrueType fonts, gs_type1.ps and/or gs_ttf.ps will redefine this.
  443. /.loadfontfile {
  444.         % According to Ed Taft, Adobe interpreters push userdict
  445.         % before loading a font, and pop it afterwards.
  446.   userdict begin
  447.     cvx exec
  448.   end
  449. } bind def
  450. /.loadfont
  451.  {        % Some buggy fonts leave extra junk on the stack,
  452.         % so we have to make a closure that records the stack depth
  453.         % in a fail-safe way.
  454.    {{.loadfontfile} .execasresource} count 1 sub 2 .execn
  455.    count exch sub { pop } repeat
  456.  } bind def
  457.  
  458. % Find an alternate font to substitute for an unknown one.
  459. % We go to some trouble to parse the font name and extract
  460. % properties from it.  Later entries take priority over earlier.
  461. /.substitutefaces [
  462.     % Guess at suitable substitutions for random unknown fonts.
  463.   [(Book) /NewCenturySchlbk 0]
  464.   [(Grot) /Helvetica 0]
  465.   [(Roman) /Times 0]
  466.   [(Chancery) /ZapfChancery-MediumItalic 0]
  467.     % If the family name appears in the font name,
  468.     % use a font from that family.
  469.   [(Arial) /Helvetica 0]
  470.   [(Avant) /AvantGarde 0]
  471.   [(Bookman) /Bookman 0]
  472.   [(Century) /NewCenturySchlbk 0]
  473.   [(Cour) /Courier 0]
  474.   [(Frut) /Helvetica 0]
  475.   [(Garamond) /Palatino 0]
  476.   [(Geneva) /Helvetica 0]
  477.   [(Helv) /Helvetica 0]
  478.   [(NewYork) /Bookman 0]
  479.   [(Pala) /Palatino 0]
  480.   [(Schlbk) /NewCenturySchlbk 0]
  481.   [(Swiss) /Helvetica 0]
  482.   [(Symbol) /Symbol 0]
  483.   [(Times) /Times 0]
  484.     % Substitute for Adobe Multiple Master fonts.
  485.   [(Minion) /Times 0]
  486.   [(Myriad) /Helvetica 0]
  487.     % If the font wants to be monospace, use Courier.
  488.   [(Monospace) /Courier 0]
  489.   [(Typewriter) /Courier 0]
  490.     % Define substitutes for the other Adobe PostScript 3 fonts.
  491.     % For some of them, the substitution is pretty bad!
  492.   [(Albertus) /Palatino 0]
  493.   [(AntiqueOlive) /Helvetica 0]
  494.   [(Bodoni) /NewCenturySchlbk 0]
  495.   [(Chicago) /Helvetica 2]
  496.   [(Clarendon) /Bookman 0]
  497.   [(Cooper) /NewCenturySchlbk 0]
  498.   [(Copperplate) /AvantGarde 0]    % inappropriate, small-cap font
  499.   [(Coronet) /ZapfChancery-MediumItalic 0]
  500.   [(Eurostile) /Helvetica 0]
  501.   [(Geneva) /Courier 2]        % should be fixed-pitch sans demi
  502.   [(GillSans) /Helvetica 2]
  503.   [(GillSans-Light) /Helvetica 0]
  504.   [(Goudy) /Palatino 0]
  505.   [(Hoefler) /NewCenturySchlbk 0]
  506.   [(Joanna) /Times 0]
  507.   [(LetterGothic) /Courier 0]    % should be fixed-pitch sans
  508.   [(LubalinGraph-Book) /Bookman 2]
  509.   [(LubalinGraph-Demi) /Bookman 0]
  510.   [(Marigold) /ZapfChancery-MediumItalic 0]
  511.   [(MonaLisa-Recut) /Palatino 0]    % inappropriate
  512.   [(Monaco) /Courier 2]        % should be fixed-pitch sans demi
  513.   [(Optima) /Helvetica 0]
  514.   [(Oxford) /ZapfChancery-MediumItalic 0]
  515.   [(Tekton) /Helvetica 0]
  516.   [(Univers) /Helvetica 0]
  517. ] readonly def
  518. /.substituteproperties [
  519.   [(It) 9] [(Oblique) 1]
  520.   [(Black) 2] [(Bd) 2] [(Bold) 2] [(bold) 2] [(Demi) 2] [(Heavy) 2] [(Sb) 2]
  521.   [(Cn) 4] [(Cond) 4] [(Narrow) 4] [(Pkg) 4] [(Compr) 4]
  522.   [(Serif) 8] [(Sans) -8]
  523. ] readonly def
  524. /.fontnameproperties {        % <int> <string|name> .fontnameproperties
  525.                 %   <int'>
  526.   .fontnamestring
  527.   .substituteproperties {
  528.     2 copy 0 get search {
  529.       pop pop pop dup length 1 sub 1 exch getinterval 3 -1 roll exch {
  530.     dup 0 ge { or } { neg not and } ifelse
  531.       } forall exch
  532.     } {
  533.       pop pop
  534.     } ifelse
  535.   } forall pop
  536. } bind def
  537. /.substitutefamilies mark
  538.   /AvantGarde
  539.     {/AvantGarde-Book /AvantGarde-BookOblique
  540.      /AvantGarde-Demi /AvantGarde-DemiOblique}
  541.   /Bookman
  542.     {/Bookman-Demi /Bookman-DemiItalic /Bookman-Light /Bookman-LightItalic}
  543.   /Courier
  544.     {/Courier /Courier-Oblique /Courier-Bold /Courier-BoldOblique}
  545.   /Helvetica
  546.     {/Helvetica /Helvetica-Oblique /Helvetica-Bold /Helvetica-BoldOblique
  547.      /Helvetica-Narrow /Helvetica-Narrow-Oblique
  548.      /Helvetica-Narrow-Bold /Helvetica-Narrow-BoldOblique}
  549.   /NewCenturySchlbk
  550.     {/NewCenturySchlbk-Roman /NewCenturySchlbk-Italic
  551.      /NewCenturySchlbk-Bold /NewCenturySchlbk-BoldItalic}
  552.   /Palatino
  553.     {/Palatino-Roman /Palatino-Italic /Palatino-Bold /Palatino-BoldItalic}
  554.   /Symbol
  555.     {/Symbol /Symbol /Symbol /Symbol}
  556.   /Times
  557.     {/Times-Roman /Times-Italic /Times-Bold /Times-BoldItalic}
  558.   /ZapfChancery-MediumItalic
  559.     {/ZapfChancery-MediumItalic}
  560. .dicttomark readonly def
  561. /.nametostring {        % <name> .nametostring <string>
  562.                 % <other> .nametostring <other>
  563.   dup type /nametype eq { .namestring } if
  564. } bind def
  565. /.fontnamestring {        % <fontname> .fontnamestring <string|name>
  566.   dup type dup /nametype eq {
  567.     pop .namestring
  568.   } {
  569.     /stringtype ne { pop () } if
  570.   } ifelse
  571. } bind def
  572. /.substitutefontname {        % <fontname> <properties> .substitutefontname
  573.                 %   <altname|null>
  574.     % Look for properties and/or a face name in the font name.
  575.     % If we find any, use Times (serif) or Helvetica (sans) as the
  576.     % base font; otherwise, use the default font.
  577.     % Note that the "substituted" font name may be the same as
  578.     % the requested one; the caller must check this.
  579.   exch .fontnamestring {
  580.     defaultfontname /Helvetica-Oblique /Helvetica-Bold /Helvetica-BoldOblique
  581.     /Helvetica-Narrow /Helvetica-Narrow-Oblique
  582.     /Helvetica-Narrow-Bold /Helvetica-Narrow-BoldOblique
  583.     /Times-Roman /Times-Italic /Times-Bold /Times-BoldItalic
  584.     /Helvetica-Narrow /Helvetica-Narrow-Oblique
  585.     /Helvetica-Narrow-Bold /Helvetica-Narrow-BoldOblique
  586.   } 3 1 roll
  587.     % Stack: facelist properties fontname
  588.     % Look for a face name.
  589.   .substitutefaces {
  590.     2 copy 0 get search {
  591.       pop pop pop
  592.     % Stack: facelist properties fontname [(pattern) family properties]
  593.       dup 2 get 4 -1 roll or 3 1 roll
  594.       1 get .substitutefamilies exch get
  595.       4 -1 roll pop 3 1 roll
  596.     } {
  597.       pop pop
  598.     } ifelse
  599.   } forall pop
  600.   1 index length mod get exec
  601. } bind def
  602. /.substitutefont {        % <fontname> .substitutefont <altname>
  603.   dup 0 exch .fontnameproperties .substitutefontname
  604.     % Only accept fonts known in the Fontmap.
  605.    Fontmap 1 index known not { pop defaultfontname } if
  606. } bind def
  607.  
  608. % If requested, make (and recognize) fake entries in FontDirectory for fonts
  609. % present in Fontmap but not actually loaded.  Thanks to Ray Johnston for
  610. % the idea behind this code.
  611. FAKEFONTS not { (%END FAKEFONTS) .skipeof } if
  612.  
  613. % We use the presence or absence of the FontMatrix key to indicate whether
  614. % a font is real or fake.  We must pop the arguments at the very end,
  615. % so that stack protection will be effective.
  616.  
  617. /definefont {        % <name> <font> definefont <font>
  618.   dup /FontMatrix known {
  619.     //definefont
  620.   } {
  621.     2 copy /FontName get findfont //definefont exch pop exch pop
  622.   } ifelse
  623. } bind odef
  624.  
  625. /scalefont {        % <font> <scale> scalefont <font>
  626.   1 index /FontMatrix known {
  627.     //scalefont
  628.   } {
  629.     1 index /FontName get findfont 1 index //scalefont
  630.     exch pop exch pop
  631.   } ifelse
  632. } bind odef
  633.  
  634. /makefont {        % <font> <matrix> makefont <font>
  635.   1 index /FontMatrix known {
  636.     //makefont
  637.   } {
  638.     1 index /FontName get findfont 1 index //makefont
  639.     exch pop exch pop
  640.   } ifelse
  641. } bind odef
  642.  
  643. /setfont {        % <font> setfont -
  644.   dup /FontMatrix known {
  645.     //setfont
  646.   } {
  647.     dup /FontName get findfont //setfont pop
  648.   } ifelse
  649. } bind odef
  650.  
  651. %END FAKEFONTS
  652.  
  653. % Define findfont so it tries to load a font if it's not found.
  654. % The Red Book requires that findfont be a procedure, not an operator,
  655. % but it still needs to restore the stacks reliably if it fails,
  656. % so we do all the work in an operator.
  657. /.findfont {
  658.   mark 1 index
  659.   //systemdict begin .dofindfont
  660.     % Define any needed aliases.
  661.   counttomark 1 sub { .aliasfont } repeat end
  662.   exch pop exch pop
  663. } odef
  664. /findfont {
  665.   .findfont
  666. } bind def
  667. % Check whether the font name we are about to look for is already on the list
  668. % of aliases we're accumulating; if so, cause an error.
  669. /.checkalias        % -mark- <alias1> ... <name> .checkalias <<same>>
  670.  { counttomark 1 sub -1 1
  671.     { index 1 index eq
  672.        { pop QUIET not
  673.       { (Unable to substitute for font.) = flush
  674.       } if
  675.      /findfont cvx /invalidfont signalerror
  676.        }
  677.       if
  678.     }
  679.    for
  680.  } bind def
  681. % Get a (non-fake) font if present in a FontDirectory.
  682. /.fontknownget        % <fontdir> <fontname> .fontknownget <font> true
  683.             % <fontdir> <fontname> .fontknownget false
  684.  { .knownget
  685.     { FAKEFONTS
  686.        { dup /FontMatrix known { true } { pop false } ifelse }
  687.        { true }
  688.       ifelse
  689.     }
  690.     { false
  691.     }
  692.    ifelse
  693.  } bind def
  694. % This is the standard procedure for handling font substitution.
  695. % Its location is per an Adobe newsgroup posting.
  696. % It is called with the font name on the stack, standing in for findfont.
  697. /.stdsubstfont {    % mark <alias1> ... <fontname> .stdsubstfont <font>
  698.       /SUBSTFONT where {
  699.     pop QUIET not {
  700.       (Substituting for font ) print dup =only
  701.       (.) = flush
  702.     } if
  703.             % No aliasing.
  704.     cleartomark mark defaultfontname
  705.       } {
  706.     dup .substitutefont
  707.     2 copy eq { pop defaultfontname } if
  708.     .checkalias
  709.     QUIET not {
  710.       SHORTERRORS {
  711.         (%%[) print 1 index =only
  712.         ( not found, substituting ) print dup =only (]%%)
  713.       } {
  714.         (Substituting font ) print dup =only
  715.         ( for ) print 1 index =only (.)
  716.       } ifelse = flush
  717.     } if
  718.             % Remove all the accumulated aliases.
  719.     counttomark 1 add 1 roll cleartomark mark exch
  720.       } ifelse
  721.   .dofindfont
  722. } bind def
  723. $error /SubstituteFont { .stdsubstfont } put
  724. % Scan the next directory on FONTPATH.
  725. /.scannextfontdir {    % - .scannextfontdir <bool>
  726.             % If we haven't scanned all the directories in
  727.             % FONTPATH, scan the next one.
  728.   null 0 1 FONTPATH length 1 sub {
  729.     FONTPATH 1 index get null ne { exch pop exit } if pop
  730.   } for dup null ne {
  731.     dup 0 eq { .scanfontbegin } if
  732.     FONTPATH 1 index get .scanfontdir
  733.     FONTPATH exch null put true
  734.   } {
  735.     pop false
  736.   } ifelse
  737. } bind def
  738. % Do the work of findfont, including substitution, defaulting, and
  739. % scanning of FONTPATH.
  740. /.dofindfont {        % <fontname> .dofindfont <font>
  741.   .tryfindfont not {
  742.             % We didn't find the font.  If we haven't scanned
  743.             % all the directories in FONTPATH, scan the next one
  744.             % now and look for the font again.
  745.     .scannextfontdir {
  746.             % Start over with an empty alias list.
  747.       counttomark 1 sub { pop } repeat
  748.       .dofindfont
  749.     } {
  750.             % No luck.  Make sure we're not already
  751.             % looking for the default font.
  752.       dup defaultfontname eq {
  753.     QUIET not {
  754.       (Unable to load default font ) print
  755.       dup =only (!  Giving up.) = flush
  756.     } if
  757.     /findfont cvx /invalidfont signalerror
  758.       } if
  759.             % Substitute for the font.  Don't alias.
  760.       $error /SubstituteFont get exec
  761.     } ifelse
  762.   } if
  763. } bind def
  764. % Try to find a font using only the present contents of Fontmap.
  765. /.tryfindfont {        % <fontname> .tryfindfont <font> true
  766.             % <fontname> .tryfindfont false
  767.   .FontDirectory 1 index .fontknownget
  768.     {            % Already loaded
  769.       exch pop true
  770.     }
  771.     { dup Fontmap exch .knownget not
  772.        {        % Unknown font name.  Look for a file with the
  773.             % same name as the requested font.
  774.      .tryloadfont
  775.        }
  776.        {        % Try each element of the Fontmap in turn.
  777.      false exch    % (in case we exhaust the list)
  778.             % Stack: fontname false fontmaplist
  779.      { exch pop
  780.        dup type /nametype eq
  781.         {            % Font alias
  782.           .checkalias .tryfindfont exit
  783.         }
  784.         { dup dup type dup /arraytype eq exch /packedarraytype eq or exch xcheck and
  785.            {        % Font with a procedural definition
  786.          exec        % The procedure will load the font.
  787.                 % Check to make sure this really happened.
  788.          .FontDirectory 1 index .knownget
  789.           { exch pop true exit }
  790.          if
  791.            }
  792.            {        % Font file name
  793.          .loadfontloop { true exit } if
  794.            }
  795.           ifelse
  796.         }
  797.        ifelse false
  798.      }
  799.      forall
  800.             % Stack: font true -or- fontname false
  801.      { true
  802.      }
  803.      {            % None of the Fontmap entries worked.
  804.                 % Try loading a file with the same name
  805.                 % as the requested font.
  806.        .tryloadfont
  807.      }
  808.     ifelse
  809.        }
  810.       ifelse
  811.     }
  812.    ifelse
  813.  } bind def
  814.  
  815. % Attempt to load a font from a file.
  816. /.tryloadfont {        % <fontname> .tryloadfont <font> true
  817.             % <fontname> .tryloadfont false
  818.   dup .nametostring
  819.         % Hack: check for the presence of the resource machinery.
  820.   /.genericrfn where {
  821.     pop
  822.     2 copy .fonttempstring /FontResourceDir getsystemparam .genericrfn
  823.     .loadfontloop {
  824.       exch pop exch pop true
  825.     } {
  826.       dup .nametostring .loadfontloop
  827.     } ifelse
  828.   } {
  829.     .loadfontloop
  830.   } ifelse
  831. } bind def
  832. /.loadfontloop {    % <fontname> <filename> .loadfontloop
  833.             %   <font> true
  834.             % -or-
  835.             %   <fontname> false
  836.             % See above regarding the use of 'loop'.
  837.     {             % Is the font name a string?
  838.     dup type /stringtype ne
  839.      { QUIET not
  840.         { (Can't find font with non-string name: ) print dup =only (.) = flush
  841.         }
  842.        if pop false exit
  843.      }
  844.     if
  845.             % Can we open the file?
  846.     findlibfile not
  847.      { QUIET not
  848.         { (Can't find \(or can't open\) font file ) print dup print
  849.           (.) = flush
  850.         }
  851.        if pop false exit
  852.      }
  853.     if
  854.  
  855.             % Stack: fontname fontfilename fontfile
  856.     DISKFONTS
  857.      { .currentglobal true .setglobal
  858.        2 index (r) file
  859.        FontFileDirectory exch 5 index exch .growput
  860.        .setglobal
  861.      }
  862.     if
  863.     QUIET not
  864.      { (Loading ) print 2 index =only
  865.        ( font from ) print 1 index print (... ) print flush
  866.      }
  867.     if
  868.     % If LOCALFONTS isn't set, load the font into local or global
  869.     % VM according to FontType; if LOCALFONTS is set, load the font
  870.     % into the current VM, which is what Adobe printers (but not
  871.     % DPS or CPSI) do.
  872.     LOCALFONTS { false } { /setglobal where } ifelse
  873.      { pop /FontType .findfontvalue { 1 eq } { false } ifelse
  874.         % .setglobal, like setglobal, aliases FontDirectory to
  875.         % GlobalFontDirectory if appropriate.  However, we mustn't
  876.         % allow the current version of .setglobal to be bound in,
  877.         % because it's different depending on language level.
  878.        .currentglobal exch /.setglobal .systemvar exec
  879.         % Remove the fake definition, if any.
  880.        .FontDirectory 3 index .undef
  881.        1 index (r) file .loadfont .FontDirectory exch
  882.        /.setglobal .systemvar exec
  883.      }
  884.      { .loadfont .FontDirectory
  885.      }
  886.     ifelse
  887.         % Stack: fontname fontfilename fontdirectory
  888.     QUIET not
  889.      { //systemdict /level2dict known
  890.         { .currentglobal false .setglobal vmstatus
  891.           true .setglobal vmstatus 3 -1 roll pop
  892.           6 -1 roll .setglobal 5
  893.         }
  894.         { vmstatus 3
  895.         }
  896.        ifelse { =only ( ) print } repeat
  897.        (done.) = flush
  898.      } if
  899.  
  900.         % Check to make sure the font was actually loaded.
  901.     dup 3 index .fontknownget
  902.      { 4 1 roll pop pop pop true exit } if
  903.  
  904.         % Maybe the file had a different FontName.
  905.         % See if we can get a FontName from the file, and if so,
  906.         % whether a font by that name exists now.
  907.     exch (r) file .findfontname
  908.      { 2 copy .fontknownget
  909.         {    % Yes.  Stack: origfontname fontdirectory filefontname fontdict
  910.           3 -1 roll pop exch
  911.           QUIET
  912.            { pop
  913.            }
  914.            { (Using ) print =only
  915.              ( font for ) print 1 index =only
  916.              (.) = flush
  917.            }
  918.           ifelse true exit
  919.         }
  920.        if pop
  921.      }
  922.     if pop
  923.  
  924.         % The font definitely did not load correctly.
  925.     QUIET not
  926.      { (Loading ) print dup =only
  927.        ( font failed.) = flush
  928.      } if
  929.     false exit
  930.  
  931.     } loop        % end of loop
  932.  
  933.  } bind def
  934.  
  935. % Define a procedure to load all known fonts.
  936. % This isn't likely to be very useful.
  937. /loadallfonts
  938.  { Fontmap { pop findfont pop } forall
  939.  } bind def
  940.  
  941. % If requested, load all the fonts defined in the Fontmap into FontDirectory
  942. % as "fake" fonts i.e., font dicts with only FontName and FontType defined.
  943. % (We define FontType only for the sake of some questionable code in the
  944. % Apple Printer Utility 2.0 font inquiry code.)
  945. %
  946. % Note that this procedure only creates fake fonts in the FontDirectory
  947. % associated with the current VM.  This is because in multi-context systems,
  948. % creating the fake fonts in local VM leads to undesirable complications.
  949. /.definefakefonts
  950.     {
  951.     }
  952.     {
  953.       (gs_fonts FAKEFONTS) VMDEBUG
  954.       Fontmap {
  955.     pop dup type /stringtype eq { cvn } if
  956.     .FontDirectory 1 index known not {
  957.       2 dict dup /FontName 3 index put
  958.       dup /FontType 1 put
  959.       .FontDirectory 3 1 roll put
  960.     } {
  961.       pop
  962.     } ifelse
  963.       } forall
  964.     }
  965. FAKEFONTS { exch } if pop def    % don't bind, .current/setglobal get redefined
  966.  
  967. % Install initial fonts from Fontmap.
  968. /.loadinitialfonts
  969.  { NOFONTMAP not
  970.     { /FONTMAP where
  971.       { pop [ FONTMAP .pathlist ]
  972.          { dup VMDEBUG findlibfile
  973.         { exch pop .loadFontmap }
  974.         { /undefinedfilename signalerror }
  975.            ifelse
  976.          }
  977.       }
  978.       { LIBPATH
  979.          { defaultfontmap 1 index .filenamedirseparator
  980.            exch concatstrings concatstrings dup VMDEBUG
  981.            (r) { file } .internalstopped
  982.         { pop pop } { .loadFontmap } ifelse
  983.          }
  984.       }
  985.      ifelse forall
  986.     }
  987.    if
  988.    .definefakefonts    % current VM is global
  989.  } def            % don't bind, .current/setglobal get redefined
  990.  
  991. % ---------------- Synthetic font support ---------------- %
  992.  
  993. % Create a new font by modifying an existing one.  paramdict contains
  994. % entries with the same keys as the ones found in a Type 1 font;
  995. % it should also contain enough empty entries to allow adding the
  996. % corresponding non-overridden entries from the original font dictionary,
  997. % including FID.  If paramdict includes a FontInfo entry, this will
  998. % also override the original font's FontInfo, entry by entry;
  999. % again, it must contain enough empty entries.
  1000.  
  1001. % Note that this procedure does not perform a definefont.
  1002.  
  1003. /.makemodifiedfont    % <fontdict> <paramdict> .makemodifiedfont <fontdict'>
  1004.  { exch
  1005.     {            % Stack: destdict key value
  1006.       1 index /FID ne
  1007.        { 2 index 2 index known
  1008.       {        % Skip fontdict entry supplied in paramdict, but
  1009.             % handle FontInfo specially.
  1010.         1 index /FontInfo eq
  1011.          { 2 index 2 index get        % new FontInfo
  1012.            1 index                % old FontInfo
  1013.         {    % Stack: destdict key value destinfo key value
  1014.           2 index 2 index known
  1015.            { pop pop }
  1016.            { 2 index 3 1 roll put }
  1017.           ifelse
  1018.         }
  1019.            forall pop
  1020.          }
  1021.         if
  1022.       }
  1023.       {        % No override, copy the fontdict entry.
  1024.         2 index 3 1 roll put
  1025.         dup dup    % to match pop pop below
  1026.       }
  1027.      ifelse
  1028.        }
  1029.       if
  1030.       pop pop
  1031.     } forall
  1032.  } bind def
  1033.  
  1034. % Make a modified font and define it.  Note that unlike definefont,
  1035. % this does not leave the font on the operand stack.
  1036.  
  1037. /.definemodifiedfont    % <fontdict> <paramdict> .definemodifiedfont -
  1038.  { .makemodifiedfont
  1039.    dup /FontName get exch definefont pop
  1040.  } bind def
  1041.